package business.global.pk.tdk;

import jsproto.c2s.cclass.pk.BasePocker;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;


/**
 * 玩打牌操作
 *
 * @author Administrator
 *
 */
public class TDKSetPosOp {

	/**
	 * 获取最大特殊牌的位置
	 *
	 * @param xValue
	 *            x值
	 * @param yValue
	 *            y值
	 * @param xPos
	 *            x位置
	 * @param yPos
	 *            y位置
	 * @return
	 */
	private final static int maxSpecialPos(int xValue, int yValue, int xPos, int yPos) {
		// 如果统计的值 < 0 ,则证明是特殊牌
		if (xValue >= 0) {
			return yPos;
		}
		if (yValue >= 0) {
			return xPos;
		}
		// 对特殊牌的值进行绝对值计算，并且比较大小
		xValue = Math.abs(xValue);
		yValue = Math.abs(yValue);

		if (xValue > yValue) {
			return xPos;
		} else {
			return yPos;
		}
	}

	/**
	 *
	 * 如果有特殊牌比较特殊牌。 计算牌值之和 进行比较大小
	 */

	public static int calcPosCountValue(ArrayList<Integer> xList, ArrayList<Integer> yList, int xPos, int yPos, boolean dai2Flag) {
		int xValue = CountCardListValue(xList, dai2Flag);
		int yValue = CountCardListValue(yList, dai2Flag);
		// 检查特殊牌
		if (xValue < 0 || yValue < 0) {
			// 获取最大特殊牌的位置
			return maxSpecialPos(xValue, yValue, xPos, yPos);
		} else {
			// 比牌时根据牌型和牌点数
			if (xValue == yValue) {
				return -1;
			} else if (xValue > yValue) {
				return xPos;
			} else {
				return yPos;
			}
		}
	}

	/**
	 *
	 * 如果有特殊牌比较特殊牌。 计算牌值之和 进行比较大小 if (计算牌值之和 大小相等)
	 * 从最后一张牌进行大小比较，如果结果一样，再比较手中最大牌的花色
	 */

	public static int calcPosCount(ArrayList<Integer> xList, ArrayList<Integer> yList, int xPos, int yPos, boolean dai2Flag) {
		int xValue = CountCardListValue(xList, dai2Flag);
		int yValue = CountCardListValue(yList, dai2Flag);
		// 检查特殊牌
		if (xValue < 0 || yValue < 0) {
			// 获取最大特殊牌的位置
			return maxSpecialPos(xValue, yValue, xPos, yPos);
		} else {
			// 比牌时根据牌型和牌点数
			if (xValue == yValue) {
				// 如果牌值之和相等
				int xIValue = 0;
				int yIValue = 0;
				int maxPos = -1;
				int maxValue = -1;
				// 从最后一张牌进行遍历比较大小
				for (int i = xList.size() - 1; i >= 0; i--) {
					xValue = TDKdefine.TDK_CARD_VALUE.valueOf(BasePocker.getCardValue(xList.get(i)), dai2Flag);
					yValue = TDKdefine.TDK_CARD_VALUE.valueOf(BasePocker.getCardValue(yList.get(i)), dai2Flag);
					if (xValue == yValue) {
						// 对牌值相同的牌进行值和颜色的比较并获取最大的牌
						xIValue = GetCardIDValue(xList.get(i), dai2Flag);
						yIValue = GetCardIDValue(yList.get(i), dai2Flag);
						if (maxValue < xIValue) {
							maxPos = xPos;
							maxValue = xIValue;
						}
						if (maxValue < yIValue) {
							maxPos = yPos;
							maxValue = yIValue;
						}
						continue;
					} else if (xValue > yValue) {
						return xPos;
					} else {
						return yPos;
					}

				}
				return maxPos;
			} else if (xValue > yValue) {
				return xPos;
			} else {
				return yPos;
			}
		}
	}

	/**
	 * 统计值 统计牌列表值
	 *
	 * @param cardLists
	 * @return
	 */
	public static int CountCardListValue(List<Integer> cardLists, boolean dai2Falg) {
		if (cardLists.size() <= 0) {
			return 0;
		}
		List<Integer> cardList = new ArrayList<>(cardLists);
		int countValue = 0;

		List<Integer> zhaDanList = ZhaDan(cardList);
		// 检查炸弹
		if (null != zhaDanList && zhaDanList.size() > 0) {
			countValue += TDKdefine.TDK_CARD_VALUE.valueOf(BasePocker.getCardValue(zhaDanList.get(0)), TDKdefine.TDK_CARD_TYPE.TDK_CARD_TYPE_ZHADAN);
			cardList.removeAll(zhaDanList);
		}
		List<Integer> wangList = DXWang(cardList);
		// 检查大小王
		if (null != wangList && wangList.size() > 0) {
			countValue += TDKdefine.TDK_CARD_VALUE.valueOf(BasePocker.getCardValue(wangList.get(0)), TDKdefine.TDK_CARD_TYPE.TDK_CARD_TYPE_WANG);
//			cardList.removeAll(wangList);
		}
		List<Integer> sanList = SanTiao(cardList);
		// 检查三条
		if (null != sanList && sanList.size() > 0) {
			countValue += TDKdefine.TDK_CARD_VALUE.valueOf(BasePocker.getCardValue(sanList.get(0)), TDKdefine.TDK_CARD_TYPE.TDK_CARD_TYPE_SAN);
			cardList.removeAll(sanList);
		}
		// 统计剩余牌的值
		for (Integer cardID : cardLists) {
			// 检查牌值大小
			if (cardID <= 0) {
				continue;
			}
			// 计算牌值
			countValue += TDKdefine.TDK_CARD_VALUE.valueOf(BasePocker.getCardValue(cardID), dai2Falg);
		}
		return countValue;
	}

	/**
	 * 检查牌型
	 *
	 * @param cardLists
	 * @param type
	 * @return
	 */
	public static int CardTypeValue(List<Integer> cardLists, TDKdefine.TDK_CARD_TYPE type, boolean dai2Flag) {
		List<Integer> cardTypeList ;
		if (TDKdefine.TDK_CARD_TYPE.TDK_CARD_TYPE_WANG.equals(type)) {
			cardTypeList = DXWang(cardLists);
		} else if (TDKdefine.TDK_CARD_TYPE.TDK_CARD_TYPE_ZHADAN.equals(type)) {
			cardTypeList = ZhaDan(cardLists);
		} else if (TDKdefine.TDK_CARD_TYPE.TDK_CARD_TYPE_SAN.equals(type)) {
			cardTypeList = SanTiao(cardLists);
		} else {
			return 0;
		}

		if (null == cardTypeList || cardTypeList.size() <= 0) {
			return 0;
		} else {
			String str = String.valueOf(TDKdefine.TDK_CARD_VALUE.valueOf(BasePocker.getCardValue(cardTypeList.get(0)), dai2Flag));
			if (str.length() <= 1) {
				str = "0" + str;
			}
			return Integer.parseInt(type.value() + str);
		}
	}

	/**
	 * 检查牌型
	 *
	 * @param cardLists
	 * @param type
	 * @return
	 */
	public static boolean CheckCardType(List<Integer> cardLists, TDKdefine.TDK_CARD_TYPE type) {
		List<Integer> cardTypeList = new ArrayList<>();
		if (TDKdefine.TDK_CARD_TYPE.TDK_CARD_TYPE_WANG.equals(type)) {
			cardTypeList = DXWang(cardLists);
		} else if (TDKdefine.TDK_CARD_TYPE.TDK_CARD_TYPE_ZHADAN.equals(type)) {
			cardTypeList = ZhaDan(cardLists);
		} else if (TDKdefine.TDK_CARD_TYPE.TDK_CARD_TYPE_SAN.equals(type)) {
			cardTypeList = SanTiao(cardLists);
		}
		if (null == cardTypeList || cardTypeList.size() <= 0) {
			return false;
		} else {
			return true;
		}
	}

	/**
	 * 获取大小王 大小王列表
	 *
	 * @param cardLists
	 *            牌列表
	 * @return
	 */
	public static List<Integer> DXWang(List<Integer> cardLists) {
		List<Integer> cardList = new ArrayList<>();
		for (Integer cardID : cardLists) {
			int cardColor = BasePocker.getCardColor(cardID);
			if (cardColor == 4) {
				cardList.add(cardID);
			}
		}
		if (cardList.size() == 2) {
			return cardList;
		} else {
			return null;
		}
	}

	/**
	 * 获取3条 三条列表
	 *
	 * @param cardLists
	 *            牌列表
	 * @return
	 */
	public static List<Integer> SanTiao(List<Integer> cardLists) {
		Map<Integer, List<Integer>> byteMap = cardLists.stream().collect(Collectors.groupingBy(p -> BasePocker.getCardValue(p)));
		// 遍历出所有重复的牌
		for (Map.Entry<Integer, List<Integer>> m : byteMap.entrySet()) {
			if (m.getValue().size() == 3) {
				return m.getValue();
			}
		}
		return null;
	}

	/**
	 * 获取炸弹 炸弹列表
	 *
	 * @param cardLists
	 *            牌列表
	 * @return
	 */
	public static List<Integer> ZhaDan(List<Integer> cardLists) {
		Map<Integer, List<Integer>> byteMap = cardLists.stream().collect(Collectors.groupingBy(p -> BasePocker.getCardValue(p)));
		// 遍历出所有重复的牌
		for (Map.Entry<Integer, List<Integer>> m : byteMap.entrySet()) {
			if (m.getValue().size() == 4) {
				return m.getValue();
			}
		}
		return null;
	}

	/**
	 * 获取牌的值
	 *
	 * @param cardID
	 * @return
	 */
	public static int GetCardIDValue(int cardID, boolean dai2Flag) {
		int color = BasePocker.getCardColor(cardID);
		int value = TDKdefine.TDK_CARD_VALUE.valueOf(BasePocker.getCardValue(cardID), dai2Flag);
		String valueStr = value + "" + color;
		return Integer.parseInt(valueStr);
	}


}
